189 research outputs found
Termination Analysis by Learning Terminating Programs
We present a novel approach to termination analysis. In a first step, the
analysis uses a program as a black-box which exhibits only a finite set of
sample traces. Each sample trace is infinite but can be represented by a finite
lasso. The analysis can "learn" a program from a termination proof for the
lasso, a program that is terminating by construction. In a second step, the
analysis checks that the set of sample traces is representative in a sense that
we can make formal. An experimental evaluation indicates that the approach is a
potentially useful addition to the portfolio of existing approaches to
termination analysis
On Verifying Complex Properties using Symbolic Shape Analysis
One of the main challenges in the verification of software systems is the
analysis of unbounded data structures with dynamic memory allocation, such as
linked data structures and arrays. We describe Bohne, a new analysis for
verifying data structures. Bohne verifies data structure operations and shows
that 1) the operations preserve data structure invariants and 2) the operations
satisfy their specifications expressed in terms of changes to the set of
objects stored in the data structure. During the analysis, Bohne infers loop
invariants in the form of disjunctions of universally quantified Boolean
combinations of formulas. To synthesize loop invariants of this form, Bohne
uses a combination of decision procedures for Monadic Second-Order Logic over
trees, SMT-LIB decision procedures (currently CVC Lite), and an automated
reasoner within the Isabelle interactive theorem prover. This architecture
shows that synthesized loop invariants can serve as a useful communication
mechanism between different decision procedures. Using Bohne, we have verified
operations on data structures such as linked lists with iterators and back
pointers, trees with and without parent pointers, two-level skip lists, array
data structures, and sorted lists. We have deployed Bohne in the Hob and Jahob
data structure analysis systems, enabling us to combine Bohne with analyses of
data structure clients and apply it in the context of larger programs. This
report describes the Bohne algorithm as well as techniques that Bohne uses to
reduce the ammount of annotations and the running time of the analysis
Reach Set Approximation through Decomposition with Low-dimensional Sets and High-dimensional Matrices
Approximating the set of reachable states of a dynamical system is an
algorithmic yet mathematically rigorous way to reason about its safety.
Although progress has been made in the development of efficient algorithms for
affine dynamical systems, available algorithms still lack scalability to ensure
their wide adoption in the industrial setting. While modern linear algebra
packages are efficient for matrices with tens of thousands of dimensions,
set-based image computations are limited to a few hundred. We propose to
decompose reach set computations such that set operations are performed in low
dimensions, while matrix operations like exponentiation are carried out in the
full dimension. Our method is applicable both in dense- and discrete-time
settings. For a set of standard benchmarks, it shows a speed-up of up to two
orders of magnitude compared to the respective state-of-the art tools, with
only modest losses in accuracy. For the dense-time case, we show an experiment
with more than 10.000 variables, roughly two orders of magnitude higher than
possible with previous approaches
Equational and membership constraints for infinite trees
We present a new constraint system with equational and membership constraints over infinite trees. It provides for complete and correct satisfiability and entailment tests and ir therefore suitable for the use in concurrent constraint programming systems which are based on cyclic data structures. Our set defining devices are greatest fixpoint solutions of regular systems of equations with a deterministic form of union. As the main technical particularity of the algorithms we present a novel memorization technique. We believe that both satisfiability and entailment tests can be implemented in an efficient and incremental manner
Reducing GUI Test Suites via Program Slicing
ABSTRACT A crucial problem in GUI testing is the identification of accurate event sequences that encode corresponding user interactions with the GUI. Ultimately, event sequences should be both feasible (i. e., executable on the GUI) and relevant (i. e., cover as much of the code as possible). So far, most work on GUI testing focused on approaches to generate feasible event sequences. In addition, based on event dependency analyses, a recently proposed static analysis approach systematically aims at selecting both relevant and feasible event sequences. However, statically analyzing event dependencies can cause the generation of a huge number of event sequences, leading to unmanageable GUI test suites that are not executable within reasonable time. In this paper we propose a refined static analysis approach based on program slicing. On the theoretical side, our approach identifies and eliminates redundant event sequences in GUI test suites. Redundant event sequences have the property that they are guaranteed to not affect the test effectiveness. On the practical side, we have implemented a slicing-based test suite reduction algorithm that approximatively identifies redundant event sequences. Our experiments on six open source GUI applications show that our reduction algorithm significantly reduces the size of GUI test suites. As a result, the overall execution time could significantly be reduced without losing test effectiveness
- …